package com.doublechaintech.retailscm.retailstorecountrycenter;

import com.doublechaintech.retailscm.CommonTokens;
import java.util.Map;
import java.util.Objects;

import com.doublechaintech.retailscm.catalog.CatalogTokens;
import com.doublechaintech.retailscm.retailstoreprovincecenter.RetailStoreProvinceCenterTokens;
import com.doublechaintech.retailscm.retailstore.RetailStoreTokens;
import com.doublechaintech.retailscm.retailstoremember.RetailStoreMemberTokens;
import com.doublechaintech.retailscm.goodssupplier.GoodsSupplierTokens;
import com.doublechaintech.retailscm.supplyorder.SupplyOrderTokens;
import com.doublechaintech.retailscm.retailstoreorder.RetailStoreOrderTokens;
import com.doublechaintech.retailscm.warehouse.WarehouseTokens;
import com.doublechaintech.retailscm.transportfleet.TransportFleetTokens;
import com.doublechaintech.retailscm.accountset.AccountSetTokens;
import com.doublechaintech.retailscm.levelonedepartment.LevelOneDepartmentTokens;
import com.doublechaintech.retailscm.skilltype.SkillTypeTokens;
import com.doublechaintech.retailscm.responsibilitytype.ResponsibilityTypeTokens;
import com.doublechaintech.retailscm.terminationreason.TerminationReasonTokens;
import com.doublechaintech.retailscm.terminationtype.TerminationTypeTokens;
import com.doublechaintech.retailscm.occupationtype.OccupationTypeTokens;
import com.doublechaintech.retailscm.leavetype.LeaveTypeTokens;
import com.doublechaintech.retailscm.salarygrade.SalaryGradeTokens;
import com.doublechaintech.retailscm.interviewtype.InterviewTypeTokens;
import com.doublechaintech.retailscm.trainingcoursetype.TrainingCourseTypeTokens;
import com.doublechaintech.retailscm.publicholiday.PublicHolidayTokens;
import com.doublechaintech.retailscm.employee.EmployeeTokens;
import com.doublechaintech.retailscm.instructor.InstructorTokens;
import com.doublechaintech.retailscm.companytraining.CompanyTrainingTokens;

public class RetailStoreCountryCenterTokens extends CommonTokens {

  static final String ALL = "__all__"; // do not assign this to common users.
  static final String SELF = "__self__";
  static final String OWNER_OBJECT_NAME = "retailStoreCountryCenter";

  public static boolean checkOptions(Map<String, Object> options, String optionToCheck) {

    if (options == null) {
      return false; // completely no option here
    }
    if (options.containsKey(ALL)) {
      // danger, debug only, might load the entire database!, really terrible
      return true;
    }
    String ownerKey = getOwnerObjectKey();
    Object ownerObject = (String) options.get(ownerKey);
    if (ownerObject == null) {
      return false;
    }
    if (!ownerObject.equals(OWNER_OBJECT_NAME)) { // is the owner?
      return false;
    }

    if (options.containsKey(optionToCheck)) {
      // options.remove(optionToCheck);
      // consume the key, can not use any more to extract the data with the same token.
      return true;
    }

    return false;
  }

  protected RetailStoreCountryCenterTokens() {
    // ensure not initialized outside the class
  }

  public static RetailStoreCountryCenterTokens of(Map<String, Object> options) {
    // ensure not initialized outside the class
    RetailStoreCountryCenterTokens tokens = new RetailStoreCountryCenterTokens(options);
    return tokens;
  }

  protected RetailStoreCountryCenterTokens(Map<String, Object> options) {
    this.options = options;
  }

  public RetailStoreCountryCenterTokens merge(String[] tokens) {
    this.parseTokens(tokens);
    return this;
  }

  public static RetailStoreCountryCenterTokens mergeAll(String[] tokens) {

    return allTokens().merge(tokens);
  }

  protected RetailStoreCountryCenterTokens setOwnerObject(String objectName) {
    ensureOptions();
    addSimpleOptions(getOwnerObjectKey(), objectName);
    return this;
  }

  public static RetailStoreCountryCenterTokens start() {
    return new RetailStoreCountryCenterTokens().setOwnerObject(OWNER_OBJECT_NAME);
  }

  public RetailStoreCountryCenterTokens withTokenFromListName(String listName) {
    addSimpleOptions(listName);
    return this;
  }

  public static RetailStoreCountryCenterTokens loadGroupTokens(String... groupNames) {
    RetailStoreCountryCenterTokens tokens = start();
    if (groupNames == null || groupNames.length == 0) {
      return allTokens();
    }

    addToken(tokens, CATALOG_LIST, groupNames, new String[] {"default"});

    addToken(tokens, RETAIL_STORE_PROVINCE_CENTER_LIST, groupNames, new String[] {"default"});

    addToken(tokens, RETAIL_STORE_LIST, groupNames, new String[] {"default"});

    addToken(tokens, RETAIL_STORE_MEMBER_LIST, groupNames, new String[] {"default"});

    addToken(tokens, GOODS_SUPPLIER_LIST, groupNames, new String[] {"default"});

    addToken(tokens, SUPPLY_ORDER_LIST, groupNames, new String[] {"default"});

    addToken(tokens, RETAIL_STORE_ORDER_LIST, groupNames, new String[] {"default"});

    addToken(tokens, WAREHOUSE_LIST, groupNames, new String[] {"default"});

    addToken(tokens, TRANSPORT_FLEET_LIST, groupNames, new String[] {"default"});

    addToken(tokens, ACCOUNT_SET_LIST, groupNames, new String[] {"default"});

    addToken(tokens, LEVEL_ONE_DEPARTMENT_LIST, groupNames, new String[] {"default"});

    addToken(tokens, SKILL_TYPE_LIST, groupNames, new String[] {"default"});

    addToken(tokens, RESPONSIBILITY_TYPE_LIST, groupNames, new String[] {"default"});

    addToken(tokens, TERMINATION_REASON_LIST, groupNames, new String[] {"default"});

    addToken(tokens, TERMINATION_TYPE_LIST, groupNames, new String[] {"default"});

    addToken(tokens, OCCUPATION_TYPE_LIST, groupNames, new String[] {"default"});

    addToken(tokens, LEAVE_TYPE_LIST, groupNames, new String[] {"default"});

    addToken(tokens, SALARY_GRADE_LIST, groupNames, new String[] {"default"});

    addToken(tokens, INTERVIEW_TYPE_LIST, groupNames, new String[] {"default"});

    addToken(tokens, TRAINING_COURSE_TYPE_LIST, groupNames, new String[] {"default"});

    addToken(tokens, PUBLIC_HOLIDAY_LIST, groupNames, new String[] {"default"});

    addToken(tokens, EMPLOYEE_LIST, groupNames, new String[] {"default"});

    addToken(tokens, INSTRUCTOR_LIST, groupNames, new String[] {"default"});

    addToken(tokens, COMPANY_TRAINING_LIST, groupNames, new String[] {"default"});

    return tokens;
  }

  private static void addToken(
      RetailStoreCountryCenterTokens pTokens,
      String pTokenName,
      String[] pGroupNames,
      String[] fieldGroups) {
    if (pGroupNames == null || fieldGroups == null) {
      return;
    }

    for (String groupName : pGroupNames) {
      for (String g : fieldGroups) {
        if (Objects.equals(groupName, g)) {
          pTokens.addSimpleOptions(pTokenName);
          break;
        }
      }
    }
  }

  public static RetailStoreCountryCenterTokens filterWithTokenViewGroups(String[] viewGroups) {

    return start()
        .withCatalogListIfViewGroupInclude(viewGroups)
        .withRetailStoreProvinceCenterListIfViewGroupInclude(viewGroups)
        .withRetailStoreListIfViewGroupInclude(viewGroups)
        .withRetailStoreMemberListIfViewGroupInclude(viewGroups)
        .withGoodsSupplierListIfViewGroupInclude(viewGroups)
        .withSupplyOrderListIfViewGroupInclude(viewGroups)
        .withRetailStoreOrderListIfViewGroupInclude(viewGroups)
        .withWarehouseListIfViewGroupInclude(viewGroups)
        .withTransportFleetListIfViewGroupInclude(viewGroups)
        .withAccountSetListIfViewGroupInclude(viewGroups)
        .withLevelOneDepartmentListIfViewGroupInclude(viewGroups)
        .withSkillTypeListIfViewGroupInclude(viewGroups)
        .withResponsibilityTypeListIfViewGroupInclude(viewGroups)
        .withTerminationReasonListIfViewGroupInclude(viewGroups)
        .withTerminationTypeListIfViewGroupInclude(viewGroups)
        .withOccupationTypeListIfViewGroupInclude(viewGroups)
        .withLeaveTypeListIfViewGroupInclude(viewGroups)
        .withSalaryGradeListIfViewGroupInclude(viewGroups)
        .withInterviewTypeListIfViewGroupInclude(viewGroups)
        .withTrainingCourseTypeListIfViewGroupInclude(viewGroups)
        .withPublicHolidayListIfViewGroupInclude(viewGroups)
        .withEmployeeListIfViewGroupInclude(viewGroups)
        .withInstructorListIfViewGroupInclude(viewGroups)
        .withCompanyTrainingListIfViewGroupInclude(viewGroups);
  }

  public static RetailStoreCountryCenterTokens allTokens() {

    return start()
        .withCatalogList()
        .withRetailStoreProvinceCenterList()
        .withRetailStoreList()
        .withRetailStoreMemberList()
        .withGoodsSupplierList()
        .withSupplyOrderList()
        .withRetailStoreOrderList()
        .withWarehouseList()
        .withTransportFleetList()
        .withAccountSetList()
        .withLevelOneDepartmentList()
        .withSkillTypeList()
        .withResponsibilityTypeList()
        .withTerminationReasonList()
        .withTerminationTypeList()
        .withOccupationTypeList()
        .withLeaveTypeList()
        .withSalaryGradeList()
        .withInterviewTypeList()
        .withTrainingCourseTypeList()
        .withPublicHolidayList()
        .withEmployeeList()
        .withInstructorList()
        .withCompanyTrainingList();
  }

  public static RetailStoreCountryCenterTokens withoutListsTokens() {

    return start();
  }

  public static Map<String, Object> all() {
    return allTokens().done();
  }

  public static Map<String, Object> withoutLists() {
    return withoutListsTokens().done();
  }

  public static Map<String, Object> empty() {
    return start().done();
  }

  public RetailStoreCountryCenterTokens analyzeAllLists() {
    addSimpleOptions(ALL_LISTS_ANALYZE);
    return this;
  }

  protected static final String CATALOG_LIST = "catalogList";

  public String getCatalogList() {
    return CATALOG_LIST;
  }

  public RetailStoreCountryCenterTokens withCatalogListIfViewGroupInclude(String[] viewGroups) {

    if (isViewGroupOneOf("产品管理", viewGroups)) {
      addSimpleOptions(CATALOG_LIST);
    }
    return this;
  }

  public RetailStoreCountryCenterTokens withCatalogList() {
    addSimpleOptions(CATALOG_LIST);
    return this;
  }

  public CatalogTokens withCatalogListTokens() {
    // addSimpleOptions(CATALOG_LIST);
    return CatalogTokens.start();
  }

  public RetailStoreCountryCenterTokens analyzeCatalogList() {
    addSimpleOptions(CATALOG_LIST + ".anaylze");
    return this;
  }

  public boolean analyzeCatalogListEnabled() {

    if (checkOptions(this.options(), CATALOG_LIST + ".anaylze")) {
      return true; // most of the case, should call here
    }
    // if not true, then query for global setting
    return checkOptions(this.options(), ALL_LISTS_ANALYZE);
  }

  public RetailStoreCountryCenterTokens extractMoreFromCatalogList(String idsSeperatedWithComma) {
    addSimpleOptions(CATALOG_LIST + ".extractIds", idsSeperatedWithComma);
    return this;
  }

  private int catalogListSortCounter = 0;

  public RetailStoreCountryCenterTokens sortCatalogListWith(String field, String descOrAsc) {
    addSortMoreOptions(CATALOG_LIST, catalogListSortCounter++, field, descOrAsc);
    return this;
  }

  private int catalogListSearchCounter = 0;

  public RetailStoreCountryCenterTokens searchCatalogListWith(
      String field, String verb, String value) {

    withCatalogList();
    addSearchMoreOptions(CATALOG_LIST, catalogListSearchCounter++, field, verb, value);
    return this;
  }

  public RetailStoreCountryCenterTokens searchAllTextOfCatalogList(String verb, String value) {
    String field = "id|name";
    addSearchMoreOptions(CATALOG_LIST, catalogListSearchCounter++, field, verb, value);
    return this;
  }

  public RetailStoreCountryCenterTokens rowsPerPageOfCatalogList(int rowsPerPage) {
    addSimpleOptions(CATALOG_LIST + "RowsPerPage", rowsPerPage);
    return this;
  }

  public RetailStoreCountryCenterTokens currentPageNumberOfCatalogList(int currentPageNumber) {
    addSimpleOptions(CATALOG_LIST + "CurrentPage", currentPageNumber);
    return this;
  }

  public RetailStoreCountryCenterTokens retainColumnsOfCatalogList(String[] columns) {
    addSimpleOptions(CATALOG_LIST + "RetainColumns", columns);
    return this;
  }

  public RetailStoreCountryCenterTokens excludeColumnsOfCatalogList(String[] columns) {
    addSimpleOptions(CATALOG_LIST + "ExcludeColumns", columns);
    return this;
  }

  protected static final String RETAIL_STORE_PROVINCE_CENTER_LIST = "retailStoreProvinceCenterList";

  public String getRetailStoreProvinceCenterList() {
    return RETAIL_STORE_PROVINCE_CENTER_LIST;
  }

  public RetailStoreCountryCenterTokens withRetailStoreProvinceCenterListIfViewGroupInclude(
      String[] viewGroups) {

    if (isViewGroupOneOf("组织机构", viewGroups)) {
      addSimpleOptions(RETAIL_STORE_PROVINCE_CENTER_LIST);
    }
    return this;
  }

  public RetailStoreCountryCenterTokens withRetailStoreProvinceCenterList() {
    addSimpleOptions(RETAIL_STORE_PROVINCE_CENTER_LIST);
    return this;
  }

  public RetailStoreProvinceCenterTokens withRetailStoreProvinceCenterListTokens() {
    // addSimpleOptions(RETAIL_STORE_PROVINCE_CENTER_LIST);
    return RetailStoreProvinceCenterTokens.start();
  }

  public RetailStoreCountryCenterTokens analyzeRetailStoreProvinceCenterList() {
    addSimpleOptions(RETAIL_STORE_PROVINCE_CENTER_LIST + ".anaylze");
    return this;
  }

  public boolean analyzeRetailStoreProvinceCenterListEnabled() {

    if (checkOptions(this.options(), RETAIL_STORE_PROVINCE_CENTER_LIST + ".anaylze")) {
      return true; // most of the case, should call here
    }
    // if not true, then query for global setting
    return checkOptions(this.options(), ALL_LISTS_ANALYZE);
  }

  public RetailStoreCountryCenterTokens extractMoreFromRetailStoreProvinceCenterList(
      String idsSeperatedWithComma) {
    addSimpleOptions(RETAIL_STORE_PROVINCE_CENTER_LIST + ".extractIds", idsSeperatedWithComma);
    return this;
  }

  private int retailStoreProvinceCenterListSortCounter = 0;

  public RetailStoreCountryCenterTokens sortRetailStoreProvinceCenterListWith(
      String field, String descOrAsc) {
    addSortMoreOptions(
        RETAIL_STORE_PROVINCE_CENTER_LIST,
        retailStoreProvinceCenterListSortCounter++,
        field,
        descOrAsc);
    return this;
  }

  private int retailStoreProvinceCenterListSearchCounter = 0;

  public RetailStoreCountryCenterTokens searchRetailStoreProvinceCenterListWith(
      String field, String verb, String value) {

    withRetailStoreProvinceCenterList();
    addSearchMoreOptions(
        RETAIL_STORE_PROVINCE_CENTER_LIST,
        retailStoreProvinceCenterListSearchCounter++,
        field,
        verb,
        value);
    return this;
  }

  public RetailStoreCountryCenterTokens searchAllTextOfRetailStoreProvinceCenterList(
      String verb, String value) {
    String field = "id|name";
    addSearchMoreOptions(
        RETAIL_STORE_PROVINCE_CENTER_LIST,
        retailStoreProvinceCenterListSearchCounter++,
        field,
        verb,
        value);
    return this;
  }

  public RetailStoreCountryCenterTokens rowsPerPageOfRetailStoreProvinceCenterList(
      int rowsPerPage) {
    addSimpleOptions(RETAIL_STORE_PROVINCE_CENTER_LIST + "RowsPerPage", rowsPerPage);
    return this;
  }

  public RetailStoreCountryCenterTokens currentPageNumberOfRetailStoreProvinceCenterList(
      int currentPageNumber) {
    addSimpleOptions(RETAIL_STORE_PROVINCE_CENTER_LIST + "CurrentPage", currentPageNumber);
    return this;
  }

  public RetailStoreCountryCenterTokens retainColumnsOfRetailStoreProvinceCenterList(
      String[] columns) {
    addSimpleOptions(RETAIL_STORE_PROVINCE_CENTER_LIST + "RetainColumns", columns);
    return this;
  }

  public RetailStoreCountryCenterTokens excludeColumnsOfRetailStoreProvinceCenterList(
      String[] columns) {
    addSimpleOptions(RETAIL_STORE_PROVINCE_CENTER_LIST + "ExcludeColumns", columns);
    return this;
  }

  protected static final String RETAIL_STORE_LIST = "retailStoreList";

  public String getRetailStoreList() {
    return RETAIL_STORE_LIST;
  }

  public RetailStoreCountryCenterTokens withRetailStoreListIfViewGroupInclude(String[] viewGroups) {

    if (isViewGroupOneOf("加盟管理", viewGroups)) {
      addSimpleOptions(RETAIL_STORE_LIST);
    }
    return this;
  }

  public RetailStoreCountryCenterTokens withRetailStoreList() {
    addSimpleOptions(RETAIL_STORE_LIST);
    return this;
  }

  public RetailStoreTokens withRetailStoreListTokens() {
    // addSimpleOptions(RETAIL_STORE_LIST);
    return RetailStoreTokens.start();
  }

  public RetailStoreCountryCenterTokens analyzeRetailStoreList() {
    addSimpleOptions(RETAIL_STORE_LIST + ".anaylze");
    return this;
  }

  public boolean analyzeRetailStoreListEnabled() {

    if (checkOptions(this.options(), RETAIL_STORE_LIST + ".anaylze")) {
      return true; // most of the case, should call here
    }
    // if not true, then query for global setting
    return checkOptions(this.options(), ALL_LISTS_ANALYZE);
  }

  public RetailStoreCountryCenterTokens extractMoreFromRetailStoreList(
      String idsSeperatedWithComma) {
    addSimpleOptions(RETAIL_STORE_LIST + ".extractIds", idsSeperatedWithComma);
    return this;
  }

  private int retailStoreListSortCounter = 0;

  public RetailStoreCountryCenterTokens sortRetailStoreListWith(String field, String descOrAsc) {
    addSortMoreOptions(RETAIL_STORE_LIST, retailStoreListSortCounter++, field, descOrAsc);
    return this;
  }

  private int retailStoreListSearchCounter = 0;

  public RetailStoreCountryCenterTokens searchRetailStoreListWith(
      String field, String verb, String value) {

    withRetailStoreList();
    addSearchMoreOptions(RETAIL_STORE_LIST, retailStoreListSearchCounter++, field, verb, value);
    return this;
  }

  public RetailStoreCountryCenterTokens searchAllTextOfRetailStoreList(String verb, String value) {
    String field = "id|name|telephone|owner|description";
    addSearchMoreOptions(RETAIL_STORE_LIST, retailStoreListSearchCounter++, field, verb, value);
    return this;
  }

  public RetailStoreCountryCenterTokens rowsPerPageOfRetailStoreList(int rowsPerPage) {
    addSimpleOptions(RETAIL_STORE_LIST + "RowsPerPage", rowsPerPage);
    return this;
  }

  public RetailStoreCountryCenterTokens currentPageNumberOfRetailStoreList(int currentPageNumber) {
    addSimpleOptions(RETAIL_STORE_LIST + "CurrentPage", currentPageNumber);
    return this;
  }

  public RetailStoreCountryCenterTokens retainColumnsOfRetailStoreList(String[] columns) {
    addSimpleOptions(RETAIL_STORE_LIST + "RetainColumns", columns);
    return this;
  }

  public RetailStoreCountryCenterTokens excludeColumnsOfRetailStoreList(String[] columns) {
    addSimpleOptions(RETAIL_STORE_LIST + "ExcludeColumns", columns);
    return this;
  }

  protected static final String RETAIL_STORE_MEMBER_LIST = "retailStoreMemberList";

  public String getRetailStoreMemberList() {
    return RETAIL_STORE_MEMBER_LIST;
  }

  public RetailStoreCountryCenterTokens withRetailStoreMemberListIfViewGroupInclude(
      String[] viewGroups) {

    if (isViewGroupOneOf("会员管理", viewGroups)) {
      addSimpleOptions(RETAIL_STORE_MEMBER_LIST);
    }
    return this;
  }

  public RetailStoreCountryCenterTokens withRetailStoreMemberList() {
    addSimpleOptions(RETAIL_STORE_MEMBER_LIST);
    return this;
  }

  public RetailStoreMemberTokens withRetailStoreMemberListTokens() {
    // addSimpleOptions(RETAIL_STORE_MEMBER_LIST);
    return RetailStoreMemberTokens.start();
  }

  public RetailStoreCountryCenterTokens analyzeRetailStoreMemberList() {
    addSimpleOptions(RETAIL_STORE_MEMBER_LIST + ".anaylze");
    return this;
  }

  public boolean analyzeRetailStoreMemberListEnabled() {

    if (checkOptions(this.options(), RETAIL_STORE_MEMBER_LIST + ".anaylze")) {
      return true; // most of the case, should call here
    }
    // if not true, then query for global setting
    return checkOptions(this.options(), ALL_LISTS_ANALYZE);
  }

  public RetailStoreCountryCenterTokens extractMoreFromRetailStoreMemberList(
      String idsSeperatedWithComma) {
    addSimpleOptions(RETAIL_STORE_MEMBER_LIST + ".extractIds", idsSeperatedWithComma);
    return this;
  }

  private int retailStoreMemberListSortCounter = 0;

  public RetailStoreCountryCenterTokens sortRetailStoreMemberListWith(
      String field, String descOrAsc) {
    addSortMoreOptions(
        RETAIL_STORE_MEMBER_LIST, retailStoreMemberListSortCounter++, field, descOrAsc);
    return this;
  }

  private int retailStoreMemberListSearchCounter = 0;

  public RetailStoreCountryCenterTokens searchRetailStoreMemberListWith(
      String field, String verb, String value) {

    withRetailStoreMemberList();
    addSearchMoreOptions(
        RETAIL_STORE_MEMBER_LIST, retailStoreMemberListSearchCounter++, field, verb, value);
    return this;
  }

  public RetailStoreCountryCenterTokens searchAllTextOfRetailStoreMemberList(
      String verb, String value) {
    String field = "id|name|mobilePhone";
    addSearchMoreOptions(
        RETAIL_STORE_MEMBER_LIST, retailStoreMemberListSearchCounter++, field, verb, value);
    return this;
  }

  public RetailStoreCountryCenterTokens rowsPerPageOfRetailStoreMemberList(int rowsPerPage) {
    addSimpleOptions(RETAIL_STORE_MEMBER_LIST + "RowsPerPage", rowsPerPage);
    return this;
  }

  public RetailStoreCountryCenterTokens currentPageNumberOfRetailStoreMemberList(
      int currentPageNumber) {
    addSimpleOptions(RETAIL_STORE_MEMBER_LIST + "CurrentPage", currentPageNumber);
    return this;
  }

  public RetailStoreCountryCenterTokens retainColumnsOfRetailStoreMemberList(String[] columns) {
    addSimpleOptions(RETAIL_STORE_MEMBER_LIST + "RetainColumns", columns);
    return this;
  }

  public RetailStoreCountryCenterTokens excludeColumnsOfRetailStoreMemberList(String[] columns) {
    addSimpleOptions(RETAIL_STORE_MEMBER_LIST + "ExcludeColumns", columns);
    return this;
  }

  protected static final String GOODS_SUPPLIER_LIST = "goodsSupplierList";

  public String getGoodsSupplierList() {
    return GOODS_SUPPLIER_LIST;
  }

  public RetailStoreCountryCenterTokens withGoodsSupplierListIfViewGroupInclude(
      String[] viewGroups) {

    if (isViewGroupOneOf("供应管理", viewGroups)) {
      addSimpleOptions(GOODS_SUPPLIER_LIST);
    }
    return this;
  }

  public RetailStoreCountryCenterTokens withGoodsSupplierList() {
    addSimpleOptions(GOODS_SUPPLIER_LIST);
    return this;
  }

  public GoodsSupplierTokens withGoodsSupplierListTokens() {
    // addSimpleOptions(GOODS_SUPPLIER_LIST);
    return GoodsSupplierTokens.start();
  }

  public RetailStoreCountryCenterTokens analyzeGoodsSupplierList() {
    addSimpleOptions(GOODS_SUPPLIER_LIST + ".anaylze");
    return this;
  }

  public boolean analyzeGoodsSupplierListEnabled() {

    if (checkOptions(this.options(), GOODS_SUPPLIER_LIST + ".anaylze")) {
      return true; // most of the case, should call here
    }
    // if not true, then query for global setting
    return checkOptions(this.options(), ALL_LISTS_ANALYZE);
  }

  public RetailStoreCountryCenterTokens extractMoreFromGoodsSupplierList(
      String idsSeperatedWithComma) {
    addSimpleOptions(GOODS_SUPPLIER_LIST + ".extractIds", idsSeperatedWithComma);
    return this;
  }

  private int goodsSupplierListSortCounter = 0;

  public RetailStoreCountryCenterTokens sortGoodsSupplierListWith(String field, String descOrAsc) {
    addSortMoreOptions(GOODS_SUPPLIER_LIST, goodsSupplierListSortCounter++, field, descOrAsc);
    return this;
  }

  private int goodsSupplierListSearchCounter = 0;

  public RetailStoreCountryCenterTokens searchGoodsSupplierListWith(
      String field, String verb, String value) {

    withGoodsSupplierList();
    addSearchMoreOptions(GOODS_SUPPLIER_LIST, goodsSupplierListSearchCounter++, field, verb, value);
    return this;
  }

  public RetailStoreCountryCenterTokens searchAllTextOfGoodsSupplierList(
      String verb, String value) {
    String field = "id|name|supplyProduct|contactNumber|description";
    addSearchMoreOptions(GOODS_SUPPLIER_LIST, goodsSupplierListSearchCounter++, field, verb, value);
    return this;
  }

  public RetailStoreCountryCenterTokens rowsPerPageOfGoodsSupplierList(int rowsPerPage) {
    addSimpleOptions(GOODS_SUPPLIER_LIST + "RowsPerPage", rowsPerPage);
    return this;
  }

  public RetailStoreCountryCenterTokens currentPageNumberOfGoodsSupplierList(
      int currentPageNumber) {
    addSimpleOptions(GOODS_SUPPLIER_LIST + "CurrentPage", currentPageNumber);
    return this;
  }

  public RetailStoreCountryCenterTokens retainColumnsOfGoodsSupplierList(String[] columns) {
    addSimpleOptions(GOODS_SUPPLIER_LIST + "RetainColumns", columns);
    return this;
  }

  public RetailStoreCountryCenterTokens excludeColumnsOfGoodsSupplierList(String[] columns) {
    addSimpleOptions(GOODS_SUPPLIER_LIST + "ExcludeColumns", columns);
    return this;
  }

  protected static final String SUPPLY_ORDER_LIST = "supplyOrderList";

  public String getSupplyOrderList() {
    return SUPPLY_ORDER_LIST;
  }

  public RetailStoreCountryCenterTokens withSupplyOrderListIfViewGroupInclude(String[] viewGroups) {

    if (isViewGroupOneOf("供应管理", viewGroups)) {
      addSimpleOptions(SUPPLY_ORDER_LIST);
    }
    return this;
  }

  public RetailStoreCountryCenterTokens withSupplyOrderList() {
    addSimpleOptions(SUPPLY_ORDER_LIST);
    return this;
  }

  public SupplyOrderTokens withSupplyOrderListTokens() {
    // addSimpleOptions(SUPPLY_ORDER_LIST);
    return SupplyOrderTokens.start();
  }

  public RetailStoreCountryCenterTokens analyzeSupplyOrderList() {
    addSimpleOptions(SUPPLY_ORDER_LIST + ".anaylze");
    return this;
  }

  public boolean analyzeSupplyOrderListEnabled() {

    if (checkOptions(this.options(), SUPPLY_ORDER_LIST + ".anaylze")) {
      return true; // most of the case, should call here
    }
    // if not true, then query for global setting
    return checkOptions(this.options(), ALL_LISTS_ANALYZE);
  }

  public RetailStoreCountryCenterTokens extractMoreFromSupplyOrderList(
      String idsSeperatedWithComma) {
    addSimpleOptions(SUPPLY_ORDER_LIST + ".extractIds", idsSeperatedWithComma);
    return this;
  }

  private int supplyOrderListSortCounter = 0;

  public RetailStoreCountryCenterTokens sortSupplyOrderListWith(String field, String descOrAsc) {
    addSortMoreOptions(SUPPLY_ORDER_LIST, supplyOrderListSortCounter++, field, descOrAsc);
    return this;
  }

  private int supplyOrderListSearchCounter = 0;

  public RetailStoreCountryCenterTokens searchSupplyOrderListWith(
      String field, String verb, String value) {

    withSupplyOrderList();
    addSearchMoreOptions(SUPPLY_ORDER_LIST, supplyOrderListSearchCounter++, field, verb, value);
    return this;
  }

  public RetailStoreCountryCenterTokens searchAllTextOfSupplyOrderList(String verb, String value) {
    String field = "id|title|contract";
    addSearchMoreOptions(SUPPLY_ORDER_LIST, supplyOrderListSearchCounter++, field, verb, value);
    return this;
  }

  public RetailStoreCountryCenterTokens rowsPerPageOfSupplyOrderList(int rowsPerPage) {
    addSimpleOptions(SUPPLY_ORDER_LIST + "RowsPerPage", rowsPerPage);
    return this;
  }

  public RetailStoreCountryCenterTokens currentPageNumberOfSupplyOrderList(int currentPageNumber) {
    addSimpleOptions(SUPPLY_ORDER_LIST + "CurrentPage", currentPageNumber);
    return this;
  }

  public RetailStoreCountryCenterTokens retainColumnsOfSupplyOrderList(String[] columns) {
    addSimpleOptions(SUPPLY_ORDER_LIST + "RetainColumns", columns);
    return this;
  }

  public RetailStoreCountryCenterTokens excludeColumnsOfSupplyOrderList(String[] columns) {
    addSimpleOptions(SUPPLY_ORDER_LIST + "ExcludeColumns", columns);
    return this;
  }

  protected static final String RETAIL_STORE_ORDER_LIST = "retailStoreOrderList";

  public String getRetailStoreOrderList() {
    return RETAIL_STORE_ORDER_LIST;
  }

  public RetailStoreCountryCenterTokens withRetailStoreOrderListIfViewGroupInclude(
      String[] viewGroups) {

    if (isViewGroupOneOf("销售管理", viewGroups)) {
      addSimpleOptions(RETAIL_STORE_ORDER_LIST);
    }
    return this;
  }

  public RetailStoreCountryCenterTokens withRetailStoreOrderList() {
    addSimpleOptions(RETAIL_STORE_ORDER_LIST);
    return this;
  }

  public RetailStoreOrderTokens withRetailStoreOrderListTokens() {
    // addSimpleOptions(RETAIL_STORE_ORDER_LIST);
    return RetailStoreOrderTokens.start();
  }

  public RetailStoreCountryCenterTokens analyzeRetailStoreOrderList() {
    addSimpleOptions(RETAIL_STORE_ORDER_LIST + ".anaylze");
    return this;
  }

  public boolean analyzeRetailStoreOrderListEnabled() {

    if (checkOptions(this.options(), RETAIL_STORE_ORDER_LIST + ".anaylze")) {
      return true; // most of the case, should call here
    }
    // if not true, then query for global setting
    return checkOptions(this.options(), ALL_LISTS_ANALYZE);
  }

  public RetailStoreCountryCenterTokens extractMoreFromRetailStoreOrderList(
      String idsSeperatedWithComma) {
    addSimpleOptions(RETAIL_STORE_ORDER_LIST + ".extractIds", idsSeperatedWithComma);
    return this;
  }

  private int retailStoreOrderListSortCounter = 0;

  public RetailStoreCountryCenterTokens sortRetailStoreOrderListWith(
      String field, String descOrAsc) {
    addSortMoreOptions(
        RETAIL_STORE_ORDER_LIST, retailStoreOrderListSortCounter++, field, descOrAsc);
    return this;
  }

  private int retailStoreOrderListSearchCounter = 0;

  public RetailStoreCountryCenterTokens searchRetailStoreOrderListWith(
      String field, String verb, String value) {

    withRetailStoreOrderList();
    addSearchMoreOptions(
        RETAIL_STORE_ORDER_LIST, retailStoreOrderListSearchCounter++, field, verb, value);
    return this;
  }

  public RetailStoreCountryCenterTokens searchAllTextOfRetailStoreOrderList(
      String verb, String value) {
    String field = "id|title|contract";
    addSearchMoreOptions(
        RETAIL_STORE_ORDER_LIST, retailStoreOrderListSearchCounter++, field, verb, value);
    return this;
  }

  public RetailStoreCountryCenterTokens rowsPerPageOfRetailStoreOrderList(int rowsPerPage) {
    addSimpleOptions(RETAIL_STORE_ORDER_LIST + "RowsPerPage", rowsPerPage);
    return this;
  }

  public RetailStoreCountryCenterTokens currentPageNumberOfRetailStoreOrderList(
      int currentPageNumber) {
    addSimpleOptions(RETAIL_STORE_ORDER_LIST + "CurrentPage", currentPageNumber);
    return this;
  }

  public RetailStoreCountryCenterTokens retainColumnsOfRetailStoreOrderList(String[] columns) {
    addSimpleOptions(RETAIL_STORE_ORDER_LIST + "RetainColumns", columns);
    return this;
  }

  public RetailStoreCountryCenterTokens excludeColumnsOfRetailStoreOrderList(String[] columns) {
    addSimpleOptions(RETAIL_STORE_ORDER_LIST + "ExcludeColumns", columns);
    return this;
  }

  protected static final String WAREHOUSE_LIST = "warehouseList";

  public String getWarehouseList() {
    return WAREHOUSE_LIST;
  }

  public RetailStoreCountryCenterTokens withWarehouseListIfViewGroupInclude(String[] viewGroups) {

    if (isViewGroupOneOf("仓配运一体化", viewGroups)) {
      addSimpleOptions(WAREHOUSE_LIST);
    }
    return this;
  }

  public RetailStoreCountryCenterTokens withWarehouseList() {
    addSimpleOptions(WAREHOUSE_LIST);
    return this;
  }

  public WarehouseTokens withWarehouseListTokens() {
    // addSimpleOptions(WAREHOUSE_LIST);
    return WarehouseTokens.start();
  }

  public RetailStoreCountryCenterTokens analyzeWarehouseList() {
    addSimpleOptions(WAREHOUSE_LIST + ".anaylze");
    return this;
  }

  public boolean analyzeWarehouseListEnabled() {

    if (checkOptions(this.options(), WAREHOUSE_LIST + ".anaylze")) {
      return true; // most of the case, should call here
    }
    // if not true, then query for global setting
    return checkOptions(this.options(), ALL_LISTS_ANALYZE);
  }

  public RetailStoreCountryCenterTokens extractMoreFromWarehouseList(String idsSeperatedWithComma) {
    addSimpleOptions(WAREHOUSE_LIST + ".extractIds", idsSeperatedWithComma);
    return this;
  }

  private int warehouseListSortCounter = 0;

  public RetailStoreCountryCenterTokens sortWarehouseListWith(String field, String descOrAsc) {
    addSortMoreOptions(WAREHOUSE_LIST, warehouseListSortCounter++, field, descOrAsc);
    return this;
  }

  private int warehouseListSearchCounter = 0;

  public RetailStoreCountryCenterTokens searchWarehouseListWith(
      String field, String verb, String value) {

    withWarehouseList();
    addSearchMoreOptions(WAREHOUSE_LIST, warehouseListSearchCounter++, field, verb, value);
    return this;
  }

  public RetailStoreCountryCenterTokens searchAllTextOfWarehouseList(String verb, String value) {
    String field = "id|location|contactNumber|totalArea|contract";
    addSearchMoreOptions(WAREHOUSE_LIST, warehouseListSearchCounter++, field, verb, value);
    return this;
  }

  public RetailStoreCountryCenterTokens rowsPerPageOfWarehouseList(int rowsPerPage) {
    addSimpleOptions(WAREHOUSE_LIST + "RowsPerPage", rowsPerPage);
    return this;
  }

  public RetailStoreCountryCenterTokens currentPageNumberOfWarehouseList(int currentPageNumber) {
    addSimpleOptions(WAREHOUSE_LIST + "CurrentPage", currentPageNumber);
    return this;
  }

  public RetailStoreCountryCenterTokens retainColumnsOfWarehouseList(String[] columns) {
    addSimpleOptions(WAREHOUSE_LIST + "RetainColumns", columns);
    return this;
  }

  public RetailStoreCountryCenterTokens excludeColumnsOfWarehouseList(String[] columns) {
    addSimpleOptions(WAREHOUSE_LIST + "ExcludeColumns", columns);
    return this;
  }

  protected static final String TRANSPORT_FLEET_LIST = "transportFleetList";

  public String getTransportFleetList() {
    return TRANSPORT_FLEET_LIST;
  }

  public RetailStoreCountryCenterTokens withTransportFleetListIfViewGroupInclude(
      String[] viewGroups) {

    if (isViewGroupOneOf("仓配运一体化", viewGroups)) {
      addSimpleOptions(TRANSPORT_FLEET_LIST);
    }
    return this;
  }

  public RetailStoreCountryCenterTokens withTransportFleetList() {
    addSimpleOptions(TRANSPORT_FLEET_LIST);
    return this;
  }

  public TransportFleetTokens withTransportFleetListTokens() {
    // addSimpleOptions(TRANSPORT_FLEET_LIST);
    return TransportFleetTokens.start();
  }

  public RetailStoreCountryCenterTokens analyzeTransportFleetList() {
    addSimpleOptions(TRANSPORT_FLEET_LIST + ".anaylze");
    return this;
  }

  public boolean analyzeTransportFleetListEnabled() {

    if (checkOptions(this.options(), TRANSPORT_FLEET_LIST + ".anaylze")) {
      return true; // most of the case, should call here
    }
    // if not true, then query for global setting
    return checkOptions(this.options(), ALL_LISTS_ANALYZE);
  }

  public RetailStoreCountryCenterTokens extractMoreFromTransportFleetList(
      String idsSeperatedWithComma) {
    addSimpleOptions(TRANSPORT_FLEET_LIST + ".extractIds", idsSeperatedWithComma);
    return this;
  }

  private int transportFleetListSortCounter = 0;

  public RetailStoreCountryCenterTokens sortTransportFleetListWith(String field, String descOrAsc) {
    addSortMoreOptions(TRANSPORT_FLEET_LIST, transportFleetListSortCounter++, field, descOrAsc);
    return this;
  }

  private int transportFleetListSearchCounter = 0;

  public RetailStoreCountryCenterTokens searchTransportFleetListWith(
      String field, String verb, String value) {

    withTransportFleetList();
    addSearchMoreOptions(
        TRANSPORT_FLEET_LIST, transportFleetListSearchCounter++, field, verb, value);
    return this;
  }

  public RetailStoreCountryCenterTokens searchAllTextOfTransportFleetList(
      String verb, String value) {
    String field = "id|name|contactNumber|contract";
    addSearchMoreOptions(
        TRANSPORT_FLEET_LIST, transportFleetListSearchCounter++, field, verb, value);
    return this;
  }

  public RetailStoreCountryCenterTokens rowsPerPageOfTransportFleetList(int rowsPerPage) {
    addSimpleOptions(TRANSPORT_FLEET_LIST + "RowsPerPage", rowsPerPage);
    return this;
  }

  public RetailStoreCountryCenterTokens currentPageNumberOfTransportFleetList(
      int currentPageNumber) {
    addSimpleOptions(TRANSPORT_FLEET_LIST + "CurrentPage", currentPageNumber);
    return this;
  }

  public RetailStoreCountryCenterTokens retainColumnsOfTransportFleetList(String[] columns) {
    addSimpleOptions(TRANSPORT_FLEET_LIST + "RetainColumns", columns);
    return this;
  }

  public RetailStoreCountryCenterTokens excludeColumnsOfTransportFleetList(String[] columns) {
    addSimpleOptions(TRANSPORT_FLEET_LIST + "ExcludeColumns", columns);
    return this;
  }

  protected static final String ACCOUNT_SET_LIST = "accountSetList";

  public String getAccountSetList() {
    return ACCOUNT_SET_LIST;
  }

  public RetailStoreCountryCenterTokens withAccountSetListIfViewGroupInclude(String[] viewGroups) {

    if (isViewGroupOneOf("财务管理", viewGroups)) {
      addSimpleOptions(ACCOUNT_SET_LIST);
    }
    return this;
  }

  public RetailStoreCountryCenterTokens withAccountSetList() {
    addSimpleOptions(ACCOUNT_SET_LIST);
    return this;
  }

  public AccountSetTokens withAccountSetListTokens() {
    // addSimpleOptions(ACCOUNT_SET_LIST);
    return AccountSetTokens.start();
  }

  public RetailStoreCountryCenterTokens analyzeAccountSetList() {
    addSimpleOptions(ACCOUNT_SET_LIST + ".anaylze");
    return this;
  }

  public boolean analyzeAccountSetListEnabled() {

    if (checkOptions(this.options(), ACCOUNT_SET_LIST + ".anaylze")) {
      return true; // most of the case, should call here
    }
    // if not true, then query for global setting
    return checkOptions(this.options(), ALL_LISTS_ANALYZE);
  }

  public RetailStoreCountryCenterTokens extractMoreFromAccountSetList(
      String idsSeperatedWithComma) {
    addSimpleOptions(ACCOUNT_SET_LIST + ".extractIds", idsSeperatedWithComma);
    return this;
  }

  private int accountSetListSortCounter = 0;

  public RetailStoreCountryCenterTokens sortAccountSetListWith(String field, String descOrAsc) {
    addSortMoreOptions(ACCOUNT_SET_LIST, accountSetListSortCounter++, field, descOrAsc);
    return this;
  }

  private int accountSetListSearchCounter = 0;

  public RetailStoreCountryCenterTokens searchAccountSetListWith(
      String field, String verb, String value) {

    withAccountSetList();
    addSearchMoreOptions(ACCOUNT_SET_LIST, accountSetListSearchCounter++, field, verb, value);
    return this;
  }

  public RetailStoreCountryCenterTokens searchAllTextOfAccountSetList(String verb, String value) {
    String field =
        "id|name|yearSet|accountingSystem|domesticCurrencyCode|domesticCurrencyName|openingBank|accountNumber";
    addSearchMoreOptions(ACCOUNT_SET_LIST, accountSetListSearchCounter++, field, verb, value);
    return this;
  }

  public RetailStoreCountryCenterTokens rowsPerPageOfAccountSetList(int rowsPerPage) {
    addSimpleOptions(ACCOUNT_SET_LIST + "RowsPerPage", rowsPerPage);
    return this;
  }

  public RetailStoreCountryCenterTokens currentPageNumberOfAccountSetList(int currentPageNumber) {
    addSimpleOptions(ACCOUNT_SET_LIST + "CurrentPage", currentPageNumber);
    return this;
  }

  public RetailStoreCountryCenterTokens retainColumnsOfAccountSetList(String[] columns) {
    addSimpleOptions(ACCOUNT_SET_LIST + "RetainColumns", columns);
    return this;
  }

  public RetailStoreCountryCenterTokens excludeColumnsOfAccountSetList(String[] columns) {
    addSimpleOptions(ACCOUNT_SET_LIST + "ExcludeColumns", columns);
    return this;
  }

  protected static final String LEVEL_ONE_DEPARTMENT_LIST = "levelOneDepartmentList";

  public String getLevelOneDepartmentList() {
    return LEVEL_ONE_DEPARTMENT_LIST;
  }

  public RetailStoreCountryCenterTokens withLevelOneDepartmentListIfViewGroupInclude(
      String[] viewGroups) {

    if (isViewGroupOneOf("组织机构", viewGroups)) {
      addSimpleOptions(LEVEL_ONE_DEPARTMENT_LIST);
    }
    return this;
  }

  public RetailStoreCountryCenterTokens withLevelOneDepartmentList() {
    addSimpleOptions(LEVEL_ONE_DEPARTMENT_LIST);
    return this;
  }

  public LevelOneDepartmentTokens withLevelOneDepartmentListTokens() {
    // addSimpleOptions(LEVEL_ONE_DEPARTMENT_LIST);
    return LevelOneDepartmentTokens.start();
  }

  public RetailStoreCountryCenterTokens analyzeLevelOneDepartmentList() {
    addSimpleOptions(LEVEL_ONE_DEPARTMENT_LIST + ".anaylze");
    return this;
  }

  public boolean analyzeLevelOneDepartmentListEnabled() {

    if (checkOptions(this.options(), LEVEL_ONE_DEPARTMENT_LIST + ".anaylze")) {
      return true; // most of the case, should call here
    }
    // if not true, then query for global setting
    return checkOptions(this.options(), ALL_LISTS_ANALYZE);
  }

  public RetailStoreCountryCenterTokens extractMoreFromLevelOneDepartmentList(
      String idsSeperatedWithComma) {
    addSimpleOptions(LEVEL_ONE_DEPARTMENT_LIST + ".extractIds", idsSeperatedWithComma);
    return this;
  }

  private int levelOneDepartmentListSortCounter = 0;

  public RetailStoreCountryCenterTokens sortLevelOneDepartmentListWith(
      String field, String descOrAsc) {
    addSortMoreOptions(
        LEVEL_ONE_DEPARTMENT_LIST, levelOneDepartmentListSortCounter++, field, descOrAsc);
    return this;
  }

  private int levelOneDepartmentListSearchCounter = 0;

  public RetailStoreCountryCenterTokens searchLevelOneDepartmentListWith(
      String field, String verb, String value) {

    withLevelOneDepartmentList();
    addSearchMoreOptions(
        LEVEL_ONE_DEPARTMENT_LIST, levelOneDepartmentListSearchCounter++, field, verb, value);
    return this;
  }

  public RetailStoreCountryCenterTokens searchAllTextOfLevelOneDepartmentList(
      String verb, String value) {
    String field = "id|name|description|manager";
    addSearchMoreOptions(
        LEVEL_ONE_DEPARTMENT_LIST, levelOneDepartmentListSearchCounter++, field, verb, value);
    return this;
  }

  public RetailStoreCountryCenterTokens rowsPerPageOfLevelOneDepartmentList(int rowsPerPage) {
    addSimpleOptions(LEVEL_ONE_DEPARTMENT_LIST + "RowsPerPage", rowsPerPage);
    return this;
  }

  public RetailStoreCountryCenterTokens currentPageNumberOfLevelOneDepartmentList(
      int currentPageNumber) {
    addSimpleOptions(LEVEL_ONE_DEPARTMENT_LIST + "CurrentPage", currentPageNumber);
    return this;
  }

  public RetailStoreCountryCenterTokens retainColumnsOfLevelOneDepartmentList(String[] columns) {
    addSimpleOptions(LEVEL_ONE_DEPARTMENT_LIST + "RetainColumns", columns);
    return this;
  }

  public RetailStoreCountryCenterTokens excludeColumnsOfLevelOneDepartmentList(String[] columns) {
    addSimpleOptions(LEVEL_ONE_DEPARTMENT_LIST + "ExcludeColumns", columns);
    return this;
  }

  protected static final String SKILL_TYPE_LIST = "skillTypeList";

  public String getSkillTypeList() {
    return SKILL_TYPE_LIST;
  }

  public RetailStoreCountryCenterTokens withSkillTypeListIfViewGroupInclude(String[] viewGroups) {

    if (isViewGroupOneOf("人力资源", viewGroups)) {
      addSimpleOptions(SKILL_TYPE_LIST);
    }
    return this;
  }

  public RetailStoreCountryCenterTokens withSkillTypeList() {
    addSimpleOptions(SKILL_TYPE_LIST);
    return this;
  }

  public SkillTypeTokens withSkillTypeListTokens() {
    // addSimpleOptions(SKILL_TYPE_LIST);
    return SkillTypeTokens.start();
  }

  public RetailStoreCountryCenterTokens analyzeSkillTypeList() {
    addSimpleOptions(SKILL_TYPE_LIST + ".anaylze");
    return this;
  }

  public boolean analyzeSkillTypeListEnabled() {

    if (checkOptions(this.options(), SKILL_TYPE_LIST + ".anaylze")) {
      return true; // most of the case, should call here
    }
    // if not true, then query for global setting
    return checkOptions(this.options(), ALL_LISTS_ANALYZE);
  }

  public RetailStoreCountryCenterTokens extractMoreFromSkillTypeList(String idsSeperatedWithComma) {
    addSimpleOptions(SKILL_TYPE_LIST + ".extractIds", idsSeperatedWithComma);
    return this;
  }

  private int skillTypeListSortCounter = 0;

  public RetailStoreCountryCenterTokens sortSkillTypeListWith(String field, String descOrAsc) {
    addSortMoreOptions(SKILL_TYPE_LIST, skillTypeListSortCounter++, field, descOrAsc);
    return this;
  }

  private int skillTypeListSearchCounter = 0;

  public RetailStoreCountryCenterTokens searchSkillTypeListWith(
      String field, String verb, String value) {

    withSkillTypeList();
    addSearchMoreOptions(SKILL_TYPE_LIST, skillTypeListSearchCounter++, field, verb, value);
    return this;
  }

  public RetailStoreCountryCenterTokens searchAllTextOfSkillTypeList(String verb, String value) {
    String field = "id|code|description";
    addSearchMoreOptions(SKILL_TYPE_LIST, skillTypeListSearchCounter++, field, verb, value);
    return this;
  }

  public RetailStoreCountryCenterTokens rowsPerPageOfSkillTypeList(int rowsPerPage) {
    addSimpleOptions(SKILL_TYPE_LIST + "RowsPerPage", rowsPerPage);
    return this;
  }

  public RetailStoreCountryCenterTokens currentPageNumberOfSkillTypeList(int currentPageNumber) {
    addSimpleOptions(SKILL_TYPE_LIST + "CurrentPage", currentPageNumber);
    return this;
  }

  public RetailStoreCountryCenterTokens retainColumnsOfSkillTypeList(String[] columns) {
    addSimpleOptions(SKILL_TYPE_LIST + "RetainColumns", columns);
    return this;
  }

  public RetailStoreCountryCenterTokens excludeColumnsOfSkillTypeList(String[] columns) {
    addSimpleOptions(SKILL_TYPE_LIST + "ExcludeColumns", columns);
    return this;
  }

  protected static final String RESPONSIBILITY_TYPE_LIST = "responsibilityTypeList";

  public String getResponsibilityTypeList() {
    return RESPONSIBILITY_TYPE_LIST;
  }

  public RetailStoreCountryCenterTokens withResponsibilityTypeListIfViewGroupInclude(
      String[] viewGroups) {

    if (isViewGroupOneOf("人力资源", viewGroups)) {
      addSimpleOptions(RESPONSIBILITY_TYPE_LIST);
    }
    return this;
  }

  public RetailStoreCountryCenterTokens withResponsibilityTypeList() {
    addSimpleOptions(RESPONSIBILITY_TYPE_LIST);
    return this;
  }

  public ResponsibilityTypeTokens withResponsibilityTypeListTokens() {
    // addSimpleOptions(RESPONSIBILITY_TYPE_LIST);
    return ResponsibilityTypeTokens.start();
  }

  public RetailStoreCountryCenterTokens analyzeResponsibilityTypeList() {
    addSimpleOptions(RESPONSIBILITY_TYPE_LIST + ".anaylze");
    return this;
  }

  public boolean analyzeResponsibilityTypeListEnabled() {

    if (checkOptions(this.options(), RESPONSIBILITY_TYPE_LIST + ".anaylze")) {
      return true; // most of the case, should call here
    }
    // if not true, then query for global setting
    return checkOptions(this.options(), ALL_LISTS_ANALYZE);
  }

  public RetailStoreCountryCenterTokens extractMoreFromResponsibilityTypeList(
      String idsSeperatedWithComma) {
    addSimpleOptions(RESPONSIBILITY_TYPE_LIST + ".extractIds", idsSeperatedWithComma);
    return this;
  }

  private int responsibilityTypeListSortCounter = 0;

  public RetailStoreCountryCenterTokens sortResponsibilityTypeListWith(
      String field, String descOrAsc) {
    addSortMoreOptions(
        RESPONSIBILITY_TYPE_LIST, responsibilityTypeListSortCounter++, field, descOrAsc);
    return this;
  }

  private int responsibilityTypeListSearchCounter = 0;

  public RetailStoreCountryCenterTokens searchResponsibilityTypeListWith(
      String field, String verb, String value) {

    withResponsibilityTypeList();
    addSearchMoreOptions(
        RESPONSIBILITY_TYPE_LIST, responsibilityTypeListSearchCounter++, field, verb, value);
    return this;
  }

  public RetailStoreCountryCenterTokens searchAllTextOfResponsibilityTypeList(
      String verb, String value) {
    String field = "id|code|baseDescription|detailDescription";
    addSearchMoreOptions(
        RESPONSIBILITY_TYPE_LIST, responsibilityTypeListSearchCounter++, field, verb, value);
    return this;
  }

  public RetailStoreCountryCenterTokens rowsPerPageOfResponsibilityTypeList(int rowsPerPage) {
    addSimpleOptions(RESPONSIBILITY_TYPE_LIST + "RowsPerPage", rowsPerPage);
    return this;
  }

  public RetailStoreCountryCenterTokens currentPageNumberOfResponsibilityTypeList(
      int currentPageNumber) {
    addSimpleOptions(RESPONSIBILITY_TYPE_LIST + "CurrentPage", currentPageNumber);
    return this;
  }

  public RetailStoreCountryCenterTokens retainColumnsOfResponsibilityTypeList(String[] columns) {
    addSimpleOptions(RESPONSIBILITY_TYPE_LIST + "RetainColumns", columns);
    return this;
  }

  public RetailStoreCountryCenterTokens excludeColumnsOfResponsibilityTypeList(String[] columns) {
    addSimpleOptions(RESPONSIBILITY_TYPE_LIST + "ExcludeColumns", columns);
    return this;
  }

  protected static final String TERMINATION_REASON_LIST = "terminationReasonList";

  public String getTerminationReasonList() {
    return TERMINATION_REASON_LIST;
  }

  public RetailStoreCountryCenterTokens withTerminationReasonListIfViewGroupInclude(
      String[] viewGroups) {

    if (isViewGroupOneOf("人力资源", viewGroups)) {
      addSimpleOptions(TERMINATION_REASON_LIST);
    }
    return this;
  }

  public RetailStoreCountryCenterTokens withTerminationReasonList() {
    addSimpleOptions(TERMINATION_REASON_LIST);
    return this;
  }

  public TerminationReasonTokens withTerminationReasonListTokens() {
    // addSimpleOptions(TERMINATION_REASON_LIST);
    return TerminationReasonTokens.start();
  }

  public RetailStoreCountryCenterTokens analyzeTerminationReasonList() {
    addSimpleOptions(TERMINATION_REASON_LIST + ".anaylze");
    return this;
  }

  public boolean analyzeTerminationReasonListEnabled() {

    if (checkOptions(this.options(), TERMINATION_REASON_LIST + ".anaylze")) {
      return true; // most of the case, should call here
    }
    // if not true, then query for global setting
    return checkOptions(this.options(), ALL_LISTS_ANALYZE);
  }

  public RetailStoreCountryCenterTokens extractMoreFromTerminationReasonList(
      String idsSeperatedWithComma) {
    addSimpleOptions(TERMINATION_REASON_LIST + ".extractIds", idsSeperatedWithComma);
    return this;
  }

  private int terminationReasonListSortCounter = 0;

  public RetailStoreCountryCenterTokens sortTerminationReasonListWith(
      String field, String descOrAsc) {
    addSortMoreOptions(
        TERMINATION_REASON_LIST, terminationReasonListSortCounter++, field, descOrAsc);
    return this;
  }

  private int terminationReasonListSearchCounter = 0;

  public RetailStoreCountryCenterTokens searchTerminationReasonListWith(
      String field, String verb, String value) {

    withTerminationReasonList();
    addSearchMoreOptions(
        TERMINATION_REASON_LIST, terminationReasonListSearchCounter++, field, verb, value);
    return this;
  }

  public RetailStoreCountryCenterTokens searchAllTextOfTerminationReasonList(
      String verb, String value) {
    String field = "id|code|description";
    addSearchMoreOptions(
        TERMINATION_REASON_LIST, terminationReasonListSearchCounter++, field, verb, value);
    return this;
  }

  public RetailStoreCountryCenterTokens rowsPerPageOfTerminationReasonList(int rowsPerPage) {
    addSimpleOptions(TERMINATION_REASON_LIST + "RowsPerPage", rowsPerPage);
    return this;
  }

  public RetailStoreCountryCenterTokens currentPageNumberOfTerminationReasonList(
      int currentPageNumber) {
    addSimpleOptions(TERMINATION_REASON_LIST + "CurrentPage", currentPageNumber);
    return this;
  }

  public RetailStoreCountryCenterTokens retainColumnsOfTerminationReasonList(String[] columns) {
    addSimpleOptions(TERMINATION_REASON_LIST + "RetainColumns", columns);
    return this;
  }

  public RetailStoreCountryCenterTokens excludeColumnsOfTerminationReasonList(String[] columns) {
    addSimpleOptions(TERMINATION_REASON_LIST + "ExcludeColumns", columns);
    return this;
  }

  protected static final String TERMINATION_TYPE_LIST = "terminationTypeList";

  public String getTerminationTypeList() {
    return TERMINATION_TYPE_LIST;
  }

  public RetailStoreCountryCenterTokens withTerminationTypeListIfViewGroupInclude(
      String[] viewGroups) {

    if (isViewGroupOneOf("人力资源", viewGroups)) {
      addSimpleOptions(TERMINATION_TYPE_LIST);
    }
    return this;
  }

  public RetailStoreCountryCenterTokens withTerminationTypeList() {
    addSimpleOptions(TERMINATION_TYPE_LIST);
    return this;
  }

  public TerminationTypeTokens withTerminationTypeListTokens() {
    // addSimpleOptions(TERMINATION_TYPE_LIST);
    return TerminationTypeTokens.start();
  }

  public RetailStoreCountryCenterTokens analyzeTerminationTypeList() {
    addSimpleOptions(TERMINATION_TYPE_LIST + ".anaylze");
    return this;
  }

  public boolean analyzeTerminationTypeListEnabled() {

    if (checkOptions(this.options(), TERMINATION_TYPE_LIST + ".anaylze")) {
      return true; // most of the case, should call here
    }
    // if not true, then query for global setting
    return checkOptions(this.options(), ALL_LISTS_ANALYZE);
  }

  public RetailStoreCountryCenterTokens extractMoreFromTerminationTypeList(
      String idsSeperatedWithComma) {
    addSimpleOptions(TERMINATION_TYPE_LIST + ".extractIds", idsSeperatedWithComma);
    return this;
  }

  private int terminationTypeListSortCounter = 0;

  public RetailStoreCountryCenterTokens sortTerminationTypeListWith(
      String field, String descOrAsc) {
    addSortMoreOptions(TERMINATION_TYPE_LIST, terminationTypeListSortCounter++, field, descOrAsc);
    return this;
  }

  private int terminationTypeListSearchCounter = 0;

  public RetailStoreCountryCenterTokens searchTerminationTypeListWith(
      String field, String verb, String value) {

    withTerminationTypeList();
    addSearchMoreOptions(
        TERMINATION_TYPE_LIST, terminationTypeListSearchCounter++, field, verb, value);
    return this;
  }

  public RetailStoreCountryCenterTokens searchAllTextOfTerminationTypeList(
      String verb, String value) {
    String field = "id|code|baseDescription|detailDescription";
    addSearchMoreOptions(
        TERMINATION_TYPE_LIST, terminationTypeListSearchCounter++, field, verb, value);
    return this;
  }

  public RetailStoreCountryCenterTokens rowsPerPageOfTerminationTypeList(int rowsPerPage) {
    addSimpleOptions(TERMINATION_TYPE_LIST + "RowsPerPage", rowsPerPage);
    return this;
  }

  public RetailStoreCountryCenterTokens currentPageNumberOfTerminationTypeList(
      int currentPageNumber) {
    addSimpleOptions(TERMINATION_TYPE_LIST + "CurrentPage", currentPageNumber);
    return this;
  }

  public RetailStoreCountryCenterTokens retainColumnsOfTerminationTypeList(String[] columns) {
    addSimpleOptions(TERMINATION_TYPE_LIST + "RetainColumns", columns);
    return this;
  }

  public RetailStoreCountryCenterTokens excludeColumnsOfTerminationTypeList(String[] columns) {
    addSimpleOptions(TERMINATION_TYPE_LIST + "ExcludeColumns", columns);
    return this;
  }

  protected static final String OCCUPATION_TYPE_LIST = "occupationTypeList";

  public String getOccupationTypeList() {
    return OCCUPATION_TYPE_LIST;
  }

  public RetailStoreCountryCenterTokens withOccupationTypeListIfViewGroupInclude(
      String[] viewGroups) {

    if (isViewGroupOneOf("人力资源", viewGroups)) {
      addSimpleOptions(OCCUPATION_TYPE_LIST);
    }
    return this;
  }

  public RetailStoreCountryCenterTokens withOccupationTypeList() {
    addSimpleOptions(OCCUPATION_TYPE_LIST);
    return this;
  }

  public OccupationTypeTokens withOccupationTypeListTokens() {
    // addSimpleOptions(OCCUPATION_TYPE_LIST);
    return OccupationTypeTokens.start();
  }

  public RetailStoreCountryCenterTokens analyzeOccupationTypeList() {
    addSimpleOptions(OCCUPATION_TYPE_LIST + ".anaylze");
    return this;
  }

  public boolean analyzeOccupationTypeListEnabled() {

    if (checkOptions(this.options(), OCCUPATION_TYPE_LIST + ".anaylze")) {
      return true; // most of the case, should call here
    }
    // if not true, then query for global setting
    return checkOptions(this.options(), ALL_LISTS_ANALYZE);
  }

  public RetailStoreCountryCenterTokens extractMoreFromOccupationTypeList(
      String idsSeperatedWithComma) {
    addSimpleOptions(OCCUPATION_TYPE_LIST + ".extractIds", idsSeperatedWithComma);
    return this;
  }

  private int occupationTypeListSortCounter = 0;

  public RetailStoreCountryCenterTokens sortOccupationTypeListWith(String field, String descOrAsc) {
    addSortMoreOptions(OCCUPATION_TYPE_LIST, occupationTypeListSortCounter++, field, descOrAsc);
    return this;
  }

  private int occupationTypeListSearchCounter = 0;

  public RetailStoreCountryCenterTokens searchOccupationTypeListWith(
      String field, String verb, String value) {

    withOccupationTypeList();
    addSearchMoreOptions(
        OCCUPATION_TYPE_LIST, occupationTypeListSearchCounter++, field, verb, value);
    return this;
  }

  public RetailStoreCountryCenterTokens searchAllTextOfOccupationTypeList(
      String verb, String value) {
    String field = "id|code|description|detailDescription";
    addSearchMoreOptions(
        OCCUPATION_TYPE_LIST, occupationTypeListSearchCounter++, field, verb, value);
    return this;
  }

  public RetailStoreCountryCenterTokens rowsPerPageOfOccupationTypeList(int rowsPerPage) {
    addSimpleOptions(OCCUPATION_TYPE_LIST + "RowsPerPage", rowsPerPage);
    return this;
  }

  public RetailStoreCountryCenterTokens currentPageNumberOfOccupationTypeList(
      int currentPageNumber) {
    addSimpleOptions(OCCUPATION_TYPE_LIST + "CurrentPage", currentPageNumber);
    return this;
  }

  public RetailStoreCountryCenterTokens retainColumnsOfOccupationTypeList(String[] columns) {
    addSimpleOptions(OCCUPATION_TYPE_LIST + "RetainColumns", columns);
    return this;
  }

  public RetailStoreCountryCenterTokens excludeColumnsOfOccupationTypeList(String[] columns) {
    addSimpleOptions(OCCUPATION_TYPE_LIST + "ExcludeColumns", columns);
    return this;
  }

  protected static final String LEAVE_TYPE_LIST = "leaveTypeList";

  public String getLeaveTypeList() {
    return LEAVE_TYPE_LIST;
  }

  public RetailStoreCountryCenterTokens withLeaveTypeListIfViewGroupInclude(String[] viewGroups) {

    if (isViewGroupOneOf("人力资源", viewGroups)) {
      addSimpleOptions(LEAVE_TYPE_LIST);
    }
    return this;
  }

  public RetailStoreCountryCenterTokens withLeaveTypeList() {
    addSimpleOptions(LEAVE_TYPE_LIST);
    return this;
  }

  public LeaveTypeTokens withLeaveTypeListTokens() {
    // addSimpleOptions(LEAVE_TYPE_LIST);
    return LeaveTypeTokens.start();
  }

  public RetailStoreCountryCenterTokens analyzeLeaveTypeList() {
    addSimpleOptions(LEAVE_TYPE_LIST + ".anaylze");
    return this;
  }

  public boolean analyzeLeaveTypeListEnabled() {

    if (checkOptions(this.options(), LEAVE_TYPE_LIST + ".anaylze")) {
      return true; // most of the case, should call here
    }
    // if not true, then query for global setting
    return checkOptions(this.options(), ALL_LISTS_ANALYZE);
  }

  public RetailStoreCountryCenterTokens extractMoreFromLeaveTypeList(String idsSeperatedWithComma) {
    addSimpleOptions(LEAVE_TYPE_LIST + ".extractIds", idsSeperatedWithComma);
    return this;
  }

  private int leaveTypeListSortCounter = 0;

  public RetailStoreCountryCenterTokens sortLeaveTypeListWith(String field, String descOrAsc) {
    addSortMoreOptions(LEAVE_TYPE_LIST, leaveTypeListSortCounter++, field, descOrAsc);
    return this;
  }

  private int leaveTypeListSearchCounter = 0;

  public RetailStoreCountryCenterTokens searchLeaveTypeListWith(
      String field, String verb, String value) {

    withLeaveTypeList();
    addSearchMoreOptions(LEAVE_TYPE_LIST, leaveTypeListSearchCounter++, field, verb, value);
    return this;
  }

  public RetailStoreCountryCenterTokens searchAllTextOfLeaveTypeList(String verb, String value) {
    String field = "id|code|description|detailDescription";
    addSearchMoreOptions(LEAVE_TYPE_LIST, leaveTypeListSearchCounter++, field, verb, value);
    return this;
  }

  public RetailStoreCountryCenterTokens rowsPerPageOfLeaveTypeList(int rowsPerPage) {
    addSimpleOptions(LEAVE_TYPE_LIST + "RowsPerPage", rowsPerPage);
    return this;
  }

  public RetailStoreCountryCenterTokens currentPageNumberOfLeaveTypeList(int currentPageNumber) {
    addSimpleOptions(LEAVE_TYPE_LIST + "CurrentPage", currentPageNumber);
    return this;
  }

  public RetailStoreCountryCenterTokens retainColumnsOfLeaveTypeList(String[] columns) {
    addSimpleOptions(LEAVE_TYPE_LIST + "RetainColumns", columns);
    return this;
  }

  public RetailStoreCountryCenterTokens excludeColumnsOfLeaveTypeList(String[] columns) {
    addSimpleOptions(LEAVE_TYPE_LIST + "ExcludeColumns", columns);
    return this;
  }

  protected static final String SALARY_GRADE_LIST = "salaryGradeList";

  public String getSalaryGradeList() {
    return SALARY_GRADE_LIST;
  }

  public RetailStoreCountryCenterTokens withSalaryGradeListIfViewGroupInclude(String[] viewGroups) {

    if (isViewGroupOneOf("人力资源", viewGroups)) {
      addSimpleOptions(SALARY_GRADE_LIST);
    }
    return this;
  }

  public RetailStoreCountryCenterTokens withSalaryGradeList() {
    addSimpleOptions(SALARY_GRADE_LIST);
    return this;
  }

  public SalaryGradeTokens withSalaryGradeListTokens() {
    // addSimpleOptions(SALARY_GRADE_LIST);
    return SalaryGradeTokens.start();
  }

  public RetailStoreCountryCenterTokens analyzeSalaryGradeList() {
    addSimpleOptions(SALARY_GRADE_LIST + ".anaylze");
    return this;
  }

  public boolean analyzeSalaryGradeListEnabled() {

    if (checkOptions(this.options(), SALARY_GRADE_LIST + ".anaylze")) {
      return true; // most of the case, should call here
    }
    // if not true, then query for global setting
    return checkOptions(this.options(), ALL_LISTS_ANALYZE);
  }

  public RetailStoreCountryCenterTokens extractMoreFromSalaryGradeList(
      String idsSeperatedWithComma) {
    addSimpleOptions(SALARY_GRADE_LIST + ".extractIds", idsSeperatedWithComma);
    return this;
  }

  private int salaryGradeListSortCounter = 0;

  public RetailStoreCountryCenterTokens sortSalaryGradeListWith(String field, String descOrAsc) {
    addSortMoreOptions(SALARY_GRADE_LIST, salaryGradeListSortCounter++, field, descOrAsc);
    return this;
  }

  private int salaryGradeListSearchCounter = 0;

  public RetailStoreCountryCenterTokens searchSalaryGradeListWith(
      String field, String verb, String value) {

    withSalaryGradeList();
    addSearchMoreOptions(SALARY_GRADE_LIST, salaryGradeListSearchCounter++, field, verb, value);
    return this;
  }

  public RetailStoreCountryCenterTokens searchAllTextOfSalaryGradeList(String verb, String value) {
    String field = "id|code|name|detailDescription";
    addSearchMoreOptions(SALARY_GRADE_LIST, salaryGradeListSearchCounter++, field, verb, value);
    return this;
  }

  public RetailStoreCountryCenterTokens rowsPerPageOfSalaryGradeList(int rowsPerPage) {
    addSimpleOptions(SALARY_GRADE_LIST + "RowsPerPage", rowsPerPage);
    return this;
  }

  public RetailStoreCountryCenterTokens currentPageNumberOfSalaryGradeList(int currentPageNumber) {
    addSimpleOptions(SALARY_GRADE_LIST + "CurrentPage", currentPageNumber);
    return this;
  }

  public RetailStoreCountryCenterTokens retainColumnsOfSalaryGradeList(String[] columns) {
    addSimpleOptions(SALARY_GRADE_LIST + "RetainColumns", columns);
    return this;
  }

  public RetailStoreCountryCenterTokens excludeColumnsOfSalaryGradeList(String[] columns) {
    addSimpleOptions(SALARY_GRADE_LIST + "ExcludeColumns", columns);
    return this;
  }

  protected static final String INTERVIEW_TYPE_LIST = "interviewTypeList";

  public String getInterviewTypeList() {
    return INTERVIEW_TYPE_LIST;
  }

  public RetailStoreCountryCenterTokens withInterviewTypeListIfViewGroupInclude(
      String[] viewGroups) {

    if (isViewGroupOneOf("人力资源", viewGroups)) {
      addSimpleOptions(INTERVIEW_TYPE_LIST);
    }
    return this;
  }

  public RetailStoreCountryCenterTokens withInterviewTypeList() {
    addSimpleOptions(INTERVIEW_TYPE_LIST);
    return this;
  }

  public InterviewTypeTokens withInterviewTypeListTokens() {
    // addSimpleOptions(INTERVIEW_TYPE_LIST);
    return InterviewTypeTokens.start();
  }

  public RetailStoreCountryCenterTokens analyzeInterviewTypeList() {
    addSimpleOptions(INTERVIEW_TYPE_LIST + ".anaylze");
    return this;
  }

  public boolean analyzeInterviewTypeListEnabled() {

    if (checkOptions(this.options(), INTERVIEW_TYPE_LIST + ".anaylze")) {
      return true; // most of the case, should call here
    }
    // if not true, then query for global setting
    return checkOptions(this.options(), ALL_LISTS_ANALYZE);
  }

  public RetailStoreCountryCenterTokens extractMoreFromInterviewTypeList(
      String idsSeperatedWithComma) {
    addSimpleOptions(INTERVIEW_TYPE_LIST + ".extractIds", idsSeperatedWithComma);
    return this;
  }

  private int interviewTypeListSortCounter = 0;

  public RetailStoreCountryCenterTokens sortInterviewTypeListWith(String field, String descOrAsc) {
    addSortMoreOptions(INTERVIEW_TYPE_LIST, interviewTypeListSortCounter++, field, descOrAsc);
    return this;
  }

  private int interviewTypeListSearchCounter = 0;

  public RetailStoreCountryCenterTokens searchInterviewTypeListWith(
      String field, String verb, String value) {

    withInterviewTypeList();
    addSearchMoreOptions(INTERVIEW_TYPE_LIST, interviewTypeListSearchCounter++, field, verb, value);
    return this;
  }

  public RetailStoreCountryCenterTokens searchAllTextOfInterviewTypeList(
      String verb, String value) {
    String field = "id|code|description|detailDescription";
    addSearchMoreOptions(INTERVIEW_TYPE_LIST, interviewTypeListSearchCounter++, field, verb, value);
    return this;
  }

  public RetailStoreCountryCenterTokens rowsPerPageOfInterviewTypeList(int rowsPerPage) {
    addSimpleOptions(INTERVIEW_TYPE_LIST + "RowsPerPage", rowsPerPage);
    return this;
  }

  public RetailStoreCountryCenterTokens currentPageNumberOfInterviewTypeList(
      int currentPageNumber) {
    addSimpleOptions(INTERVIEW_TYPE_LIST + "CurrentPage", currentPageNumber);
    return this;
  }

  public RetailStoreCountryCenterTokens retainColumnsOfInterviewTypeList(String[] columns) {
    addSimpleOptions(INTERVIEW_TYPE_LIST + "RetainColumns", columns);
    return this;
  }

  public RetailStoreCountryCenterTokens excludeColumnsOfInterviewTypeList(String[] columns) {
    addSimpleOptions(INTERVIEW_TYPE_LIST + "ExcludeColumns", columns);
    return this;
  }

  protected static final String TRAINING_COURSE_TYPE_LIST = "trainingCourseTypeList";

  public String getTrainingCourseTypeList() {
    return TRAINING_COURSE_TYPE_LIST;
  }

  public RetailStoreCountryCenterTokens withTrainingCourseTypeListIfViewGroupInclude(
      String[] viewGroups) {

    if (isViewGroupOneOf("人力资源", viewGroups)) {
      addSimpleOptions(TRAINING_COURSE_TYPE_LIST);
    }
    return this;
  }

  public RetailStoreCountryCenterTokens withTrainingCourseTypeList() {
    addSimpleOptions(TRAINING_COURSE_TYPE_LIST);
    return this;
  }

  public TrainingCourseTypeTokens withTrainingCourseTypeListTokens() {
    // addSimpleOptions(TRAINING_COURSE_TYPE_LIST);
    return TrainingCourseTypeTokens.start();
  }

  public RetailStoreCountryCenterTokens analyzeTrainingCourseTypeList() {
    addSimpleOptions(TRAINING_COURSE_TYPE_LIST + ".anaylze");
    return this;
  }

  public boolean analyzeTrainingCourseTypeListEnabled() {

    if (checkOptions(this.options(), TRAINING_COURSE_TYPE_LIST + ".anaylze")) {
      return true; // most of the case, should call here
    }
    // if not true, then query for global setting
    return checkOptions(this.options(), ALL_LISTS_ANALYZE);
  }

  public RetailStoreCountryCenterTokens extractMoreFromTrainingCourseTypeList(
      String idsSeperatedWithComma) {
    addSimpleOptions(TRAINING_COURSE_TYPE_LIST + ".extractIds", idsSeperatedWithComma);
    return this;
  }

  private int trainingCourseTypeListSortCounter = 0;

  public RetailStoreCountryCenterTokens sortTrainingCourseTypeListWith(
      String field, String descOrAsc) {
    addSortMoreOptions(
        TRAINING_COURSE_TYPE_LIST, trainingCourseTypeListSortCounter++, field, descOrAsc);
    return this;
  }

  private int trainingCourseTypeListSearchCounter = 0;

  public RetailStoreCountryCenterTokens searchTrainingCourseTypeListWith(
      String field, String verb, String value) {

    withTrainingCourseTypeList();
    addSearchMoreOptions(
        TRAINING_COURSE_TYPE_LIST, trainingCourseTypeListSearchCounter++, field, verb, value);
    return this;
  }

  public RetailStoreCountryCenterTokens searchAllTextOfTrainingCourseTypeList(
      String verb, String value) {
    String field = "id|code|name|description";
    addSearchMoreOptions(
        TRAINING_COURSE_TYPE_LIST, trainingCourseTypeListSearchCounter++, field, verb, value);
    return this;
  }

  public RetailStoreCountryCenterTokens rowsPerPageOfTrainingCourseTypeList(int rowsPerPage) {
    addSimpleOptions(TRAINING_COURSE_TYPE_LIST + "RowsPerPage", rowsPerPage);
    return this;
  }

  public RetailStoreCountryCenterTokens currentPageNumberOfTrainingCourseTypeList(
      int currentPageNumber) {
    addSimpleOptions(TRAINING_COURSE_TYPE_LIST + "CurrentPage", currentPageNumber);
    return this;
  }

  public RetailStoreCountryCenterTokens retainColumnsOfTrainingCourseTypeList(String[] columns) {
    addSimpleOptions(TRAINING_COURSE_TYPE_LIST + "RetainColumns", columns);
    return this;
  }

  public RetailStoreCountryCenterTokens excludeColumnsOfTrainingCourseTypeList(String[] columns) {
    addSimpleOptions(TRAINING_COURSE_TYPE_LIST + "ExcludeColumns", columns);
    return this;
  }

  protected static final String PUBLIC_HOLIDAY_LIST = "publicHolidayList";

  public String getPublicHolidayList() {
    return PUBLIC_HOLIDAY_LIST;
  }

  public RetailStoreCountryCenterTokens withPublicHolidayListIfViewGroupInclude(
      String[] viewGroups) {

    if (isViewGroupOneOf("人力资源", viewGroups)) {
      addSimpleOptions(PUBLIC_HOLIDAY_LIST);
    }
    return this;
  }

  public RetailStoreCountryCenterTokens withPublicHolidayList() {
    addSimpleOptions(PUBLIC_HOLIDAY_LIST);
    return this;
  }

  public PublicHolidayTokens withPublicHolidayListTokens() {
    // addSimpleOptions(PUBLIC_HOLIDAY_LIST);
    return PublicHolidayTokens.start();
  }

  public RetailStoreCountryCenterTokens analyzePublicHolidayList() {
    addSimpleOptions(PUBLIC_HOLIDAY_LIST + ".anaylze");
    return this;
  }

  public boolean analyzePublicHolidayListEnabled() {

    if (checkOptions(this.options(), PUBLIC_HOLIDAY_LIST + ".anaylze")) {
      return true; // most of the case, should call here
    }
    // if not true, then query for global setting
    return checkOptions(this.options(), ALL_LISTS_ANALYZE);
  }

  public RetailStoreCountryCenterTokens extractMoreFromPublicHolidayList(
      String idsSeperatedWithComma) {
    addSimpleOptions(PUBLIC_HOLIDAY_LIST + ".extractIds", idsSeperatedWithComma);
    return this;
  }

  private int publicHolidayListSortCounter = 0;

  public RetailStoreCountryCenterTokens sortPublicHolidayListWith(String field, String descOrAsc) {
    addSortMoreOptions(PUBLIC_HOLIDAY_LIST, publicHolidayListSortCounter++, field, descOrAsc);
    return this;
  }

  private int publicHolidayListSearchCounter = 0;

  public RetailStoreCountryCenterTokens searchPublicHolidayListWith(
      String field, String verb, String value) {

    withPublicHolidayList();
    addSearchMoreOptions(PUBLIC_HOLIDAY_LIST, publicHolidayListSearchCounter++, field, verb, value);
    return this;
  }

  public RetailStoreCountryCenterTokens searchAllTextOfPublicHolidayList(
      String verb, String value) {
    String field = "id|code|name|description";
    addSearchMoreOptions(PUBLIC_HOLIDAY_LIST, publicHolidayListSearchCounter++, field, verb, value);
    return this;
  }

  public RetailStoreCountryCenterTokens rowsPerPageOfPublicHolidayList(int rowsPerPage) {
    addSimpleOptions(PUBLIC_HOLIDAY_LIST + "RowsPerPage", rowsPerPage);
    return this;
  }

  public RetailStoreCountryCenterTokens currentPageNumberOfPublicHolidayList(
      int currentPageNumber) {
    addSimpleOptions(PUBLIC_HOLIDAY_LIST + "CurrentPage", currentPageNumber);
    return this;
  }

  public RetailStoreCountryCenterTokens retainColumnsOfPublicHolidayList(String[] columns) {
    addSimpleOptions(PUBLIC_HOLIDAY_LIST + "RetainColumns", columns);
    return this;
  }

  public RetailStoreCountryCenterTokens excludeColumnsOfPublicHolidayList(String[] columns) {
    addSimpleOptions(PUBLIC_HOLIDAY_LIST + "ExcludeColumns", columns);
    return this;
  }

  protected static final String EMPLOYEE_LIST = "employeeList";

  public String getEmployeeList() {
    return EMPLOYEE_LIST;
  }

  public RetailStoreCountryCenterTokens withEmployeeListIfViewGroupInclude(String[] viewGroups) {

    if (isViewGroupOneOf("人力资源", viewGroups)) {
      addSimpleOptions(EMPLOYEE_LIST);
    }
    return this;
  }

  public RetailStoreCountryCenterTokens withEmployeeList() {
    addSimpleOptions(EMPLOYEE_LIST);
    return this;
  }

  public EmployeeTokens withEmployeeListTokens() {
    // addSimpleOptions(EMPLOYEE_LIST);
    return EmployeeTokens.start();
  }

  public RetailStoreCountryCenterTokens analyzeEmployeeList() {
    addSimpleOptions(EMPLOYEE_LIST + ".anaylze");
    return this;
  }

  public boolean analyzeEmployeeListEnabled() {

    if (checkOptions(this.options(), EMPLOYEE_LIST + ".anaylze")) {
      return true; // most of the case, should call here
    }
    // if not true, then query for global setting
    return checkOptions(this.options(), ALL_LISTS_ANALYZE);
  }

  public RetailStoreCountryCenterTokens extractMoreFromEmployeeList(String idsSeperatedWithComma) {
    addSimpleOptions(EMPLOYEE_LIST + ".extractIds", idsSeperatedWithComma);
    return this;
  }

  private int employeeListSortCounter = 0;

  public RetailStoreCountryCenterTokens sortEmployeeListWith(String field, String descOrAsc) {
    addSortMoreOptions(EMPLOYEE_LIST, employeeListSortCounter++, field, descOrAsc);
    return this;
  }

  private int employeeListSearchCounter = 0;

  public RetailStoreCountryCenterTokens searchEmployeeListWith(
      String field, String verb, String value) {

    withEmployeeList();
    addSearchMoreOptions(EMPLOYEE_LIST, employeeListSearchCounter++, field, verb, value);
    return this;
  }

  public RetailStoreCountryCenterTokens searchAllTextOfEmployeeList(String verb, String value) {
    String field = "id|title|familyName|givenName|email|city|address|cellPhone|salaryAccount";
    addSearchMoreOptions(EMPLOYEE_LIST, employeeListSearchCounter++, field, verb, value);
    return this;
  }

  public RetailStoreCountryCenterTokens rowsPerPageOfEmployeeList(int rowsPerPage) {
    addSimpleOptions(EMPLOYEE_LIST + "RowsPerPage", rowsPerPage);
    return this;
  }

  public RetailStoreCountryCenterTokens currentPageNumberOfEmployeeList(int currentPageNumber) {
    addSimpleOptions(EMPLOYEE_LIST + "CurrentPage", currentPageNumber);
    return this;
  }

  public RetailStoreCountryCenterTokens retainColumnsOfEmployeeList(String[] columns) {
    addSimpleOptions(EMPLOYEE_LIST + "RetainColumns", columns);
    return this;
  }

  public RetailStoreCountryCenterTokens excludeColumnsOfEmployeeList(String[] columns) {
    addSimpleOptions(EMPLOYEE_LIST + "ExcludeColumns", columns);
    return this;
  }

  protected static final String INSTRUCTOR_LIST = "instructorList";

  public String getInstructorList() {
    return INSTRUCTOR_LIST;
  }

  public RetailStoreCountryCenterTokens withInstructorListIfViewGroupInclude(String[] viewGroups) {

    if (isViewGroupOneOf("人力资源", viewGroups)) {
      addSimpleOptions(INSTRUCTOR_LIST);
    }
    return this;
  }

  public RetailStoreCountryCenterTokens withInstructorList() {
    addSimpleOptions(INSTRUCTOR_LIST);
    return this;
  }

  public InstructorTokens withInstructorListTokens() {
    // addSimpleOptions(INSTRUCTOR_LIST);
    return InstructorTokens.start();
  }

  public RetailStoreCountryCenterTokens analyzeInstructorList() {
    addSimpleOptions(INSTRUCTOR_LIST + ".anaylze");
    return this;
  }

  public boolean analyzeInstructorListEnabled() {

    if (checkOptions(this.options(), INSTRUCTOR_LIST + ".anaylze")) {
      return true; // most of the case, should call here
    }
    // if not true, then query for global setting
    return checkOptions(this.options(), ALL_LISTS_ANALYZE);
  }

  public RetailStoreCountryCenterTokens extractMoreFromInstructorList(
      String idsSeperatedWithComma) {
    addSimpleOptions(INSTRUCTOR_LIST + ".extractIds", idsSeperatedWithComma);
    return this;
  }

  private int instructorListSortCounter = 0;

  public RetailStoreCountryCenterTokens sortInstructorListWith(String field, String descOrAsc) {
    addSortMoreOptions(INSTRUCTOR_LIST, instructorListSortCounter++, field, descOrAsc);
    return this;
  }

  private int instructorListSearchCounter = 0;

  public RetailStoreCountryCenterTokens searchInstructorListWith(
      String field, String verb, String value) {

    withInstructorList();
    addSearchMoreOptions(INSTRUCTOR_LIST, instructorListSearchCounter++, field, verb, value);
    return this;
  }

  public RetailStoreCountryCenterTokens searchAllTextOfInstructorList(String verb, String value) {
    String field = "id|title|familyName|givenName|cellPhone|email|introduction";
    addSearchMoreOptions(INSTRUCTOR_LIST, instructorListSearchCounter++, field, verb, value);
    return this;
  }

  public RetailStoreCountryCenterTokens rowsPerPageOfInstructorList(int rowsPerPage) {
    addSimpleOptions(INSTRUCTOR_LIST + "RowsPerPage", rowsPerPage);
    return this;
  }

  public RetailStoreCountryCenterTokens currentPageNumberOfInstructorList(int currentPageNumber) {
    addSimpleOptions(INSTRUCTOR_LIST + "CurrentPage", currentPageNumber);
    return this;
  }

  public RetailStoreCountryCenterTokens retainColumnsOfInstructorList(String[] columns) {
    addSimpleOptions(INSTRUCTOR_LIST + "RetainColumns", columns);
    return this;
  }

  public RetailStoreCountryCenterTokens excludeColumnsOfInstructorList(String[] columns) {
    addSimpleOptions(INSTRUCTOR_LIST + "ExcludeColumns", columns);
    return this;
  }

  protected static final String COMPANY_TRAINING_LIST = "companyTrainingList";

  public String getCompanyTrainingList() {
    return COMPANY_TRAINING_LIST;
  }

  public RetailStoreCountryCenterTokens withCompanyTrainingListIfViewGroupInclude(
      String[] viewGroups) {

    if (isViewGroupOneOf("人力资源", viewGroups)) {
      addSimpleOptions(COMPANY_TRAINING_LIST);
    }
    return this;
  }

  public RetailStoreCountryCenterTokens withCompanyTrainingList() {
    addSimpleOptions(COMPANY_TRAINING_LIST);
    return this;
  }

  public CompanyTrainingTokens withCompanyTrainingListTokens() {
    // addSimpleOptions(COMPANY_TRAINING_LIST);
    return CompanyTrainingTokens.start();
  }

  public RetailStoreCountryCenterTokens analyzeCompanyTrainingList() {
    addSimpleOptions(COMPANY_TRAINING_LIST + ".anaylze");
    return this;
  }

  public boolean analyzeCompanyTrainingListEnabled() {

    if (checkOptions(this.options(), COMPANY_TRAINING_LIST + ".anaylze")) {
      return true; // most of the case, should call here
    }
    // if not true, then query for global setting
    return checkOptions(this.options(), ALL_LISTS_ANALYZE);
  }

  public RetailStoreCountryCenterTokens extractMoreFromCompanyTrainingList(
      String idsSeperatedWithComma) {
    addSimpleOptions(COMPANY_TRAINING_LIST + ".extractIds", idsSeperatedWithComma);
    return this;
  }

  private int companyTrainingListSortCounter = 0;

  public RetailStoreCountryCenterTokens sortCompanyTrainingListWith(
      String field, String descOrAsc) {
    addSortMoreOptions(COMPANY_TRAINING_LIST, companyTrainingListSortCounter++, field, descOrAsc);
    return this;
  }

  private int companyTrainingListSearchCounter = 0;

  public RetailStoreCountryCenterTokens searchCompanyTrainingListWith(
      String field, String verb, String value) {

    withCompanyTrainingList();
    addSearchMoreOptions(
        COMPANY_TRAINING_LIST, companyTrainingListSearchCounter++, field, verb, value);
    return this;
  }

  public RetailStoreCountryCenterTokens searchAllTextOfCompanyTrainingList(
      String verb, String value) {
    String field = "id|title";
    addSearchMoreOptions(
        COMPANY_TRAINING_LIST, companyTrainingListSearchCounter++, field, verb, value);
    return this;
  }

  public RetailStoreCountryCenterTokens rowsPerPageOfCompanyTrainingList(int rowsPerPage) {
    addSimpleOptions(COMPANY_TRAINING_LIST + "RowsPerPage", rowsPerPage);
    return this;
  }

  public RetailStoreCountryCenterTokens currentPageNumberOfCompanyTrainingList(
      int currentPageNumber) {
    addSimpleOptions(COMPANY_TRAINING_LIST + "CurrentPage", currentPageNumber);
    return this;
  }

  public RetailStoreCountryCenterTokens retainColumnsOfCompanyTrainingList(String[] columns) {
    addSimpleOptions(COMPANY_TRAINING_LIST + "RetainColumns", columns);
    return this;
  }

  public RetailStoreCountryCenterTokens excludeColumnsOfCompanyTrainingList(String[] columns) {
    addSimpleOptions(COMPANY_TRAINING_LIST + "ExcludeColumns", columns);
    return this;
  }

  public RetailStoreCountryCenterTokens searchEntireObjectText(String verb, String value) {

    searchAllTextOfCatalogList(verb, value);
    searchAllTextOfRetailStoreProvinceCenterList(verb, value);
    searchAllTextOfRetailStoreList(verb, value);
    searchAllTextOfRetailStoreMemberList(verb, value);
    searchAllTextOfGoodsSupplierList(verb, value);
    searchAllTextOfSupplyOrderList(verb, value);
    searchAllTextOfRetailStoreOrderList(verb, value);
    searchAllTextOfWarehouseList(verb, value);
    searchAllTextOfTransportFleetList(verb, value);
    searchAllTextOfAccountSetList(verb, value);
    searchAllTextOfLevelOneDepartmentList(verb, value);
    searchAllTextOfSkillTypeList(verb, value);
    searchAllTextOfResponsibilityTypeList(verb, value);
    searchAllTextOfTerminationReasonList(verb, value);
    searchAllTextOfTerminationTypeList(verb, value);
    searchAllTextOfOccupationTypeList(verb, value);
    searchAllTextOfLeaveTypeList(verb, value);
    searchAllTextOfSalaryGradeList(verb, value);
    searchAllTextOfInterviewTypeList(verb, value);
    searchAllTextOfTrainingCourseTypeList(verb, value);
    searchAllTextOfPublicHolidayList(verb, value);
    searchAllTextOfEmployeeList(verb, value);
    searchAllTextOfInstructorList(verb, value);
    searchAllTextOfCompanyTrainingList(verb, value);
    return this;
  }
}
